package com.crm.customers.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.crm.customers.dao.ContractDao;
import com.crm.customers.dao.ContractMoneylogDao;
import com.crm.customers.dao.CustomerDao;
import com.crm.customers.model.Contract;
import com.crm.customers.model.ContractMoneylog;
import com.crm.customers.model.CustomerInfo;
import com.crm.customers.service.ApproveItemService;
import com.crm.customers.service.ContractFilesService;
import com.crm.customers.service.ContractMoneylogService;
import com.crm.customers.service.ContractPerformanceService;
import com.crm.sys.dao.ApproveConfigureDao;
import com.crm.sys.model.ApproveConfigure;
import com.crm.util.Constants;

@Service("contractMoneylogService")
public class ContractMoneylogServiceImpl implements ContractMoneylogService {
	
	@Autowired
	private ContractMoneylogDao contractMoneylogDao;
	@Autowired
	private ContractDao contractDao;
	@Autowired
	private ApproveConfigureDao approveConfigureDao;
	@Autowired
	private ApproveItemService approveItemService;
	@Autowired
	private CustomerDao customerDao;
	@Autowired
	private ContractPerformanceService contractPerformanceService;
	@Autowired
	private ContractFilesService contractFilesService;

	@Override
	public int insertMoneyLog(ContractMoneylog cml) throws Exception  
	{
		int result = 0;
		//判断合同是否存在 
		 if(cml.getContractid()==null){
			 cml.setContractid(0L);
		}
		cml.setState(1);//设置为 已收款/付款
		cml.setApprovalstatus(Constants.ApproveState.ONE);//设置为审批中
		ContractMoneylog resultObj = contractMoneylogDao.insertSelective(cml);
		if(resultObj.getId()!=null&&resultObj.getId()>0){
			CustomerInfo  customer = customerDao.getCustomerInfoById(cml.getCusid());
			Long urlId = resultObj.getContractid();
			 //获取审批流程 插入到审批表  
			String approveCode  = Constants.ApproveCode.ARRIVAL;
			if(cml.getType()==0){
				approveCode  =  Constants.ApproveCode.PAYMENT;
				urlId = cml.getId();//付款申请 需要显示付款详情页面  所以穿付款详情ID
			}
			ApproveConfigure  cig = approveConfigureDao.selectByPrimaryKey(approveCode); 
			approveItemService.saveApprove(cig, resultObj.getId(),urlId,cml.getCreateuser(), customer.getCname());
			result = 1;
		 }
		return result;
	}

	@Override
	public List<ContractMoneylog> getContractMoneylogList(ContractMoneylog cml,Integer pageNo, Integer pageSize) {
		
		if (pageNo != null && pageSize != null) {
			cml.setStartsize((pageNo-1)*pageSize);
			cml.setEndsize(pageSize);
		}
		List<ContractMoneylog>  list =  contractMoneylogDao.selectListByParam(cml);
		return list;
	}

	@Override
	public int updateContractMoneylogApproveState(ContractMoneylog cml) {
		int result =0;
		//审核通过 判断
		if(cml.getApprovalstatus()==Constants.ApproveState.TOW){
			//审核通过   设置收付款状态为已收付款
			cml.setState(Constants.MoneylogState.ONE);  
			result = contractMoneylogDao.updateByPrimaryKeySelective(cml);
			if(result>0){
				//查询合同及 收付款金额
				ContractMoneylog cmObj = contractMoneylogDao.selectById(cml.getId());
				Contract ct = cmObj.getContractInfo();
				//垫款不进入该判断
				if(ct!=null&&ct.getId()!=null){
					Contract ctObj = new Contract();
					ctObj.setId(ct.getId());
					
					//2017/12/4 修改判断
					//企业回款通过审批后，与符合消除垫款的人的垫款相比较，如果大于垫款数，就消除垫款，然后再用剩余的钱，与其他的垫款比较
					//每次都要查 已通过审批的金额，和付款记录中是预付款的记录做比较，然后得出没有使用的回款，继续消除垫款
					if (ct.getType() == 1) {
						//创建一个moneylog对象
						ContractMoneylog appcml = new ContractMoneylog();
						appcml.setContractid(ct.getId());  //合同id
						appcml.setApprovalstatus(Constants.ApproveState.TOW); //已通过审核
						//第一步：获取现在可以使用的回款金额（已通过审批的总回款金额-该合同下人才合同付款类型是预付款的记录）
						Integer approvedBackMoney = contractMoneylogDao.getAllApprovedMoney(appcml);
						Integer approvedAdvanceMoney = contractMoneylogDao.getAllApprovedAdvanceMoney(appcml);
						if (approvedBackMoney == null) {
							approvedBackMoney = 0;
						}
						if (approvedAdvanceMoney == null) {
							approvedAdvanceMoney = 0;
						}
						//获取当前可使用的回款金额，如果还有余额，消垫款，如果没有，那就跳过
						if (approvedBackMoney > approvedAdvanceMoney) {
							Integer outMoney = approvedBackMoney-approvedAdvanceMoney;
							//第二步，获取人才合同中符合条件的已有的未绑定合同的垫款记录列表
							List<ContractMoneylog> approvedAdvanceList = contractMoneylogDao.getAllApproveAdvanceList(appcml);
							//第三步：循环，与当前可有金额比较，看是否可以消除垫款
							for (ContractMoneylog forcml : approvedAdvanceList) {
								//先判断金额是否大于垫款金额
								if (outMoney >= forcml.getTotalamount()) {
									//消除垫款
									//获取人才合同
									Contract scon = new Contract();
									scon.setCusid(forcml.getCusid());
									scon.setPid(ct.getId());
									scon = contractDao.getSonContractByParams(scon);
									if (forcml.getTotalamount() >= scon.getTotalamount()){
									
										int count = contractFilesService.getFileCountByConid(scon.getId());
										if(count<1) {
											scon.setState(Constants.ContactsState.SIX);
										}else {
											scon.setState(Constants.ContactsState.EIG);
										}
										
									} else if (scon.getTotalamount() == 0) {
										//还有一个条件，如果人才证书价格为0改变合同状态为付款完成
										int count = contractFilesService.getFileCountByConid(scon.getId());
										if(count<1) {
											scon.setState(Constants.ContactsState.SIX);
										}else {
											scon.setState(Constants.ContactsState.EIG);
										}
									
									} else {
										scon.setState(Constants.ContactsState.FOUR);
									}
									//更新合同
									contractDao.updateByPrimaryKeySelective(scon);
									//将这笔垫款消除
									forcml.setContractid(scon.getId());
									updateContractMoneylog(forcml);
									//减去垫款
									outMoney = outMoney - forcml.getTotalamount();
								}
							}
						}
						
						//判断是挂靠合同
						if(ct.getContracttype()==1) {
							//业绩计算的判断
							if (ct.getTotalmoney() >= ct.getServicecharge() && ct.getServicecharge() > 0) {
								contractPerformanceService.insertContractPerformance(ct.getId(),cmObj.getArrivaltime());
							}
						}else {
							if (ct.getTotalmoney() >0) {
								contractPerformanceService.insertContractPerformance(ct.getId(),cmObj.getArrivaltime());
							}
						}
						
					}
					/*//2017/12/1 添加判断
					//企业回款通过审批后，找出合同中人才证书价格大于等于该人才垫款总数的人才合同，获取总垫款数，与已通过审批的回款总额做对比，
					//如果回款总额大于等于总垫款数，消除垫款，绑定合同，变为人才的付款
					//如果回款总额小于总垫款数，不变
					//与统计业绩合并，因为都是与收款相关的
					if (ct.getType() == 1) {
						//创建一个moneylog对象
						ContractMoneylog appcml = new ContractMoneylog();
						appcml.setContractid(ct.getId());  //合同id
						appcml.setApprovalstatus(Constants.ApproveState.TOW); //已通过审核
						//第一步：判断所有已通过审核的回款金额
						Integer approvedBackMoney = contractMoneylogDao.getAllApprovedMoney(appcml);
						//第二步：获取人才合同中符合条件的已有的未绑定合同的垫款记录列表
						List<ContractMoneylog> approvedAdvanceList = contractMoneylogDao.getAllApproveAdvanceList(appcml);
						Integer approvedAdvanceMoney = 0;
						for (ContractMoneylog forcml1 : approvedAdvanceList){
							approvedAdvanceMoney += forcml1.getTotalamount();
						}
						//第三步：与已通过的审核金额做比较，判断是否可以消除垫款
						if (approvedBackMoney != null && approvedAdvanceMoney != null && approvedBackMoney >= approvedAdvanceMoney) {
							//符合条件，消除垫款
							for (ContractMoneylog forcml2 : approvedAdvanceList){
								//获取人才合同
								Contract scon = new Contract();
								scon.setCusid(forcml2.getCusid());
								scon.setPid(ct.getId());
								scon = contractDao.getSonContractByParams(scon);
								//将所有的垫款与合同金额做比较，判断付款结果
								//当垫款金额大于等于合同金额时 改变合同状态 为付款完成
								if (forcml2.getTotalamount() >= scon.getTotalamount()){
									scon.setState(Constants.ContactsState.SIX);
								} else if (scon.getTotalamount() == 0) {
									//还有一个条件，如果人才证书价格为0改变合同状态为付款完成
									scon.setState(Constants.ContactsState.SIX);
								} else {
									scon.setState(Constants.ContactsState.FOUR);
								}
								//更新合同
								contractDao.updateByPrimaryKeySelective(scon);
								
								//将所有这个人下的垫款绑定到合同上
								forcml2.setCreateuser(scon.getUid());
								List<ContractMoneylog> mlResultlist = getContractMoneylogInfoByContract(forcml2);
								for (ContractMoneylog mlResult : mlResultlist) {
									ContractMoneylog ml = new ContractMoneylog();
									ml.setId(mlResult.getId());
									ml.setContractid(scon.getId());
									updateContractMoneylog(ml);
								}
							}
						}
						
						//业绩计算的判断
						if (ct.getTotalmoney() >= ct.getServicecharge() && ct.getServicecharge() > 0) {
							contractPerformanceService.insertContractPerformance(ct.getId(),cmObj.getArrivaltime());
						}
					}*/
					
					//当合同金额等于 收付款金额时
					if(ct.getTotalamount()<=ct.getTotalmoney()){
						 //付款 
						 if(cmObj.getType()==0){
							 //更新合同状态为已付款 
							 int count = contractFilesService.getFileCountByConid(ctObj.getId());
								if(count<1) {
									ctObj.setState(Constants.ContactsState.SIX);
								}else {
									ctObj.setState(Constants.ContactsState.EIG);
								}
						 }else{//收款
							 //更新合同状态为已收款
							   int count = contractFilesService.getFileCountByConid(ctObj.getId());
								if(count<1) {
									ctObj.setState(Constants.ContactsState.FIVE);
								}else {
									ctObj.setState(Constants.ContactsState.SEV);
								}
						 }
					}else{
						 if(cmObj.getType()==0){
							 //更新合同状态为付款中 
							 ctObj.setState(Constants.ContactsState.FOUR);
						 }else{//收款
							 //更新合同状态为收款中
							 ctObj.setState(Constants.ContactsState.THREE);
						 }
					}
					contractDao.updateByPrimaryKeySelective(ctObj);
				}
				
			}
		}else{
			result = contractMoneylogDao.updateByPrimaryKeySelective(cml);
		} 
		return result;
	}

	@Override
	public ContractMoneylog getContractMoneylogInfo(ContractMoneylog cml) {
		//查询合同及 收付款金额
		ContractMoneylog cmObj = contractMoneylogDao.selectById(cml.getId());
		return cmObj;
	}

	@Override
	public List<ContractMoneylog> getContractMoneylogInfoByContract(
			ContractMoneylog cml) {
		return contractMoneylogDao.selectByContract(cml);
	}

	@Override
	public int updateContractMoneylog(ContractMoneylog cml) {
		return contractMoneylogDao.updateByPrimaryKeySelective(cml);
	}

	@Override
	public int selectLogCountByParams(ContractMoneylog cml) {
		return contractMoneylogDao.selectLogCountByParams(cml);
	}

	@Override
	public int selectTotalMoney(ContractMoneylog cml) {
		return contractMoneylogDao.selectTotalMoneyByParams(cml);
	}

	@Override
	public List<ContractMoneylog> selectBnakName(ContractMoneylog cml) {
		return contractMoneylogDao.selectBnakName(cml);
	}

	@Override
	public int updateContractid(ContractMoneylog cml) {
		return contractMoneylogDao.updateContractid(cml);
	}

	@Override
	public int selectskcount(ContractMoneylog cml) {
		return contractMoneylogDao.selectskcount(cml);
	}

	@Override
	public List<ContractMoneylog> getDKlistByParams(ContractMoneylog cml,int pageNo,int pageSize) {
		
		cml.setStartsize((pageNo-1)*pageSize);
		cml.setEndsize(pageSize);
		List<ContractMoneylog> list = contractMoneylogDao.getDKlistByParams(cml);
		
		return list;
	}

	@Override
	public int getcmlcountbytype(ContractMoneylog cml) {
		return contractMoneylogDao.getcmlcountbytype(cml);
	}

	@Override
	public Integer getcmlcountbycreatedate(ContractMoneylog cml) {
		Integer result = contractMoneylogDao.getcmlcountbycreatedate(cml);
		if (result == null) {
			result = 0;
		}
		return result;
	}

	@Override
	public Integer addOrCleanAdvanceMoneyLog(ContractMoneylog cml, int type) {
		/*
		 * 这玩意是2017/12/5添加的
		 * 主要是主要是在合同修改的时候，可能会涉及到增加的人才有垫款，去除的人也有垫款，但去除的人的垫款在这个合同中已经被消除了...
		 * 涉及到已去除的人的垫款恢复，新添加人的垫款绑定
		 * */
		int result = 0;
		if (type == 0) {
			//说明是去除了这个人，那垫款就要给他找回来
			//把垫款找回来
			result = contractMoneylogDao.addAdvanceMoneyLog(cml);
		} else if (type == 1) {
			//说明是增加了这个人，那就看能不能给他的垫款消了
			//那咋办呢，要看看这个人是不是有垫款，还有剩余的已付款钱，是不是够
			//这里现在废弃了
		}
		
		
		return result;
	}

}
